unit Main;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, RzPanel, ExtCtrls, RzTabs, ImgList, JvImageList, RzButton, RzBckgnd,
  RzSplit, RzCommon, ComCtrls, RzListVw, StdCtrls, RzLabel, Mask, RzEdit,
  RzLstBox, RzTrkBar, VidGrab, RzStatus, RzRadChk, JvComponentBase,
  JvThreadTimer, JvTimer, RzSpnEdt, RzLine, RzCmboBx, RzBHints,
  RzTreeVw, ToolWin, Menus, RzRadGrp,
  JvExControls, JvTracker, JvgHint, IdBaseComponent, IdComponent,
  IdTCPConnection, IdTCPClient, IdHTTP, xmldom, XMLIntf, msxmldom, XMLDoc,
  RzPrgres, PlatformDefaultStyleActnCtrls, ActnPopup, RzShellDialogs;

const
   Max_R = 5000;
   Programma = 'Bierdopjes Workshop';
   MiliSecInOneDay = 86400000;
   SUB_FONT_SIZE = 8;
   SUB_HEIGHT = 30;
   SUB_MAX_HEIGHT = 60;

type
 OrgRecord = record
  nr: integer;
  start: string;
  eind: string;
  lijn1: string;
  lijn2: string;
  end;

  OrgSub = array of OrgRecord;

  THoofdScherm = class(TForm)
    RzStatusBar1: TRzStatusBar;
    RzPageControl1: TRzPageControl;
    TabSheet1: TRzTabSheet;
    TabSheet3: TRzTabSheet;
    RzFrameController1: TRzFrameController;
    RzSplitter1: TRzSplitter;
    RzSplitter2: TRzSplitter;
    RzSplitter3: TRzSplitter;
    RzBackground3: TRzBackground;
    RzBackground4: TRzBackground;
    RzLabel2: TRzLabel;
    RegelsRzLabel: TRzLabel;
    VertalingRzLabel: TRzLabel;
    RzSplitter4: TRzSplitter;
    RzBackground2: TRzBackground;
    RzBackground5: TRzBackground;
    FilmNaam: TRzLabel;
    BedieningRzLabel: TRzLabel;
    eRegel1: TEdit;
    VertalingRegel1RzLabel: TRzLabel;
    eRegel2: TEdit;
    VertalingRegel2RzLabel: TRzLabel;
    RzToolButton1: TRzToolButton;
    RzToolButton3: TRzToolButton;
    tmrVideoSub: TJvTimer;
    RzSpinButtons1: TRzSpinButtons;
    StartTijd: TRzMaskEdit;
    VertalingStartTijdRzLabel: TRzLabel;
    VertalingEindTijdRzLabel: TRzLabel;
    EindTijd: TRzMaskEdit;
    RzSpinButtons2: TRzSpinButtons;
    RzLine1: TRzLine;
    RzLine2: TRzLine;
    RzBackground6: TRzBackground;
    lblAantalRegel1: TLabel;
    lblAantalRegel2: TLabel;
    VersieInfo: TRzVersionInfo;
    OpenSrtBestand: TOpenDialog;
    OpenVideoBestand: TOpenDialog;
    RzGroupBox1: TRzGroupBox;
    IVideoSub: TRzCheckBox;
    RzSplitter5: TRzSplitter;
    RzBackground8: TRzBackground;
    BookmarksRzLabel: TRzLabel;
    RzBackground1: TRzBackground;
    InfoRzLabel: TRzLabel;
    info: TTreeView;
    ImageList1: TImageList;
    RegelsLijst: TListView;
    ToolBar1: TToolBar;
    OpenenToolButton: TToolButton;
    SaveButton: TToolButton;
    RegelToevoegen: TToolButton;
    RegelVerwijderen: TToolButton;
    ToolButton7: TToolButton;
    OpenVideo: TToolButton;
    OpenenMenu: TPopupMenu;
    OpslaanMenu: TPopupMenu;
    OpslaanalsSrt1: TMenuItem;
    OpslaanalsBWSproject1: TMenuItem;
    ToolButton6: TToolButton;
    SaveSrtDialog: TSaveDialog;
    BookMarks: TListView;
    RzBackground9: TRzBackground;
    RzBackground10: TRzBackground;
    RzBackground7: TRzBackground;
    Opslaan1: TMenuItem;
    Opensrtbestand1: TMenuItem;
    OpenBWSproject1: TMenuItem;
    RzRadioGroup1: TRzRadioGroup;
    RzLabel13: TRzLabel;
    IFontVideo: TRzComboBox;
    BookMarkButton: TToolButton;
    BookMarkMenu: TPopupMenu;
    PlaatsBookMark1: TMenuItem;
    BookMark1: TMenuItem;
    BookMark2: TMenuItem;
    BookMark3: TMenuItem;
    BookMark4: TMenuItem;
    VerwijderBookMark1: TMenuItem;
    SubVideoRegels: TRzLabel;
    TijdVar: TRzComboBox;
    BedieningMsRzLabel: TRzLabel;
    Rewind: TRzToolButton;
    Forward: TRzToolButton;
    TabSheet4: TRzTabSheet;
    VertalingLengteTijdRzLabel: TRzLabel;
    LengteTijd: TRzMaskEdit;
    RzSpinButtons3: TRzSpinButtons;
    btnRegelsSamenvoegen: TToolButton;
    RzGroupBox2: TRzGroupBox;
    bm1: TEdit;
    lbl1: TLabel;
    bm2: TEdit;
    lbl2: TLabel;
    bm3: TEdit;
    lbl3: TLabel;
    bm4: TEdit;
    lbl4: TLabel;
    RzBackground12: TRzBackground;
    RzBackground13: TRzBackground;
    RzBackground14: TRzBackground;
    RzBackground15: TRzBackground;
    lbltijd: TRzLabel;
    StatusInfo: TRzFieldStatus;
    StatusBuild: TRzFieldStatus;
    RzToolButton4: TRzToolButton;
    ToolButton3: TToolButton;
    ToolButton4: TToolButton;
    XMLHTTP: TIdHTTP;
    Video: TVideoGrabber;
    TrackBar1: TTrackBar;
    SelectSubTimer: TTimer;
    RzLabel5: TRzLabel;
    LengteRegels: TMaskEdit;
    OrgRegel1: TEdit;
    Orgregel2: TEdit;
    VolumeBar: TTrackBar;
    BedieningVolumeRzLabel: TRzLabel;
    RegelLijstMenu: TPopupMenu;
    SamenVoegen1: TMenuItem;
    Verwijderen1: TMenuItem;
    ToonOrgSub: TCheckBox;
    Metregelervoor1: TMenuItem;
    Metregelerna1: TMenuItem;
    RzLine3: TRzLine;
    VertalingBronSubRzLabel: TRzLabel;
    N1: TMenuItem;
    Opslaanorginelesub1: TMenuItem;
    N2: TMenuItem;
    Openbronsub1: TMenuItem;
    SamenVoegenMenu: TPopupMenu;
    Metregelervoor2: TMenuItem;
    Metregelerna2: TMenuItem;
    Bookmark5: TMenuItem;
    VerwijderBookmark2: TMenuItem;
    ernacontrole1: TMenuItem;
    Syncproblemen1: TMenuItem;
    Moeilijkwoord1: TMenuItem;
    Overige1: TMenuItem;
    BookMarkLijstMenu: TPopupMenu;
    BookmarkVerwijderen1: TMenuItem;
    AutoOpslaanCombo: TRzComboBox;
    RzLabel1: TRzLabel;
    RzLabel3: TRzLabel;
    AutoOpslaan: TTimer;
    Image1: TImage;
    RzLabel4: TRzLabel;
    AutoMap: TRzEdit;
    MapOpslaanButton: TRzButton;
    AutoSelectFolder: TRzSelectFolderDialog;

    procedure VerwijderDynElement(var X: OrgSub; Index: Integer);

    { Form events }
    procedure FormCreate(Sender: TObject);
    procedure FormShow(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);

    { RzToolButton(1-2-3-4) events }
    procedure RzToolButton1Click(Sender: TObject);
    procedure RzToolButton2Click(Sender: TObject);
    procedure RzToolButton3Click(Sender: TObject);
    procedure RzToolButton4Click(Sender: TObject);

    { RzSpinButtons(1-2-3) events }
    procedure RzSpinButtons1DownLeftClick(Sender: TObject);
    procedure RzSpinButtons1UpRightClick(Sender: TObject);
    procedure RzSpinButtons2DownLeftClick(Sender: TObject);
    procedure RzSpinButtons2UpRightClick(Sender: TObject);
    procedure RzSpinButtons3DownLeftClick(Sender: TObject);
    procedure RzSpinButtons3UpRightClick(Sender: TObject);

    { eRegel(1-2) events }
    procedure eRegelKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure eRegel1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure eRegel2KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure eRegel1Exit(Sender: TObject);
    procedure eRegel2Exit(Sender: TObject);
    procedure eRegel1Change(Sender: TObject);
    procedure eRegel2Change(Sender: TObject);

    { Bookmark(1-2-3-4) events }
    procedure BookMarkClick(Sender: TObject; ImageIndex: Integer);
    procedure BookMark1Click(Sender: TObject);
    procedure BookMark2Click(Sender: TObject);
    procedure BookMark3Click(Sender: TObject);
    procedure BookMark4Click(Sender: TObject);
    function RegelHeeftBookMark(regel, bookmark: Integer): Boolean;
    procedure BookMarksSelectItem(Sender: TObject; Item: TListItem; Selected: Boolean);
    procedure VerwijderBookMark1Click(Sender: TObject);
    procedure VerwijderBookmark2Click(Sender: TObject);
    procedure BookMarkLijstMenuChange(Sender: TObject; Source: TMenuItem;
      Rebuild: Boolean);

    { TijdVar events }
    procedure TijdVarKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure TijdVarKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);

    { Regel(s) events }
    procedure RegelToevoegenClick(Sender: TObject);
    procedure RegelVerwijderenClick(Sender: TObject);
    procedure RegelDblClick(Sender: TObject);
    procedure RegelsLijstSelectItem(Sender: TObject; Item: TListItem; Selected: Boolean);
    procedure RegelsLijstKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure RegelsLijstCustomDrawSubItem(Sender: TCustomListView; Item: TListItem;
        SubItem: Integer; State: TCustomDrawState; var DefaultDraw: Boolean);
    procedure OrgineleSubLaden(Bestand: string);
    procedure RegelsLijstChange(Sender: TObject; Item: TListItem;
      Change: TItemChange);
    procedure RegelLijstMenuChange(Sender: TObject; Source: TMenuItem;
      Rebuild: Boolean);

    { ToolButton(2-4) events }
    procedure OpenenToolButtonClick(Sender: TObject);
    procedure ToolButton4Click(Sender: TObject);

    { Opslaan events }
    procedure OpslaanalsSrt1Click(Sender: TObject);
    procedure Opslaan1Click(Sender: TObject);
    procedure OpslaanalsBWSproject1Click(Sender: TObject);

    { Openen events }
    procedure OpenVideoClick(Sender: TObject);

    { Video events }
    procedure VideoClick(Sender: TObject);
    procedure RewindClick(Sender: TObject);
    procedure ForwardClick(Sender: TObject);
    procedure RefreshTimerTimer(Sender: TObject);
    procedure tmrVideoSubTimer(Sender: TObject);
    procedure IFontVideoChange(Sender: TObject);
    procedure VideoFrameProgress2(Sender: TObject; FrameInfo: pFrameInfo);
    procedure SelectSubTimerTimer(Sender: TObject);
    procedure VolumeBarChange(Sender: TObject);
    procedure SamenVoegen1Click(Sender: TObject);
    procedure infoClick(Sender: TObject);
    procedure Metregelerna1Click(Sender: TObject);
    procedure Metregelervoor1Click(Sender: TObject);
    procedure Verwijderen1Click(Sender: TObject);
    procedure Openbronsub1Click(Sender: TObject);
    procedure Opslaanorginelesub1Click(Sender: TObject);
    procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
    procedure AutoOpslaanTimer(Sender: TObject);
    procedure AutoOpslaanComboChange(Sender: TObject);
    procedure MapOpslaanButtonClick(Sender: TObject);


  private
    { Private declarations }
  public
    procedure SrtBestandLaden(Bestand: string);
    procedure ToonSub;
    procedure SpeelVideoMetSubs;
    procedure SpeelVideoMetGeselecteerdeSub;
    procedure CheckSub;
    procedure VerplaatsSub(Tijd: string);
    procedure VeranderFontVideo;


    function ConverteerTijdNaarNano(Tijd: string):int64;
    function TijdAanpassen(Tijd: string; Waarde: int64):string;
    function UpdateLengte(TijdS: string; TijdE: string):string;
    function SecToTime(Sec: Int64): string;
    Function ConverteerMilliNaarTijd(MilliSeconds: integer):string;
  end;

SrtRecord = record
  nr: integer;
  start: string;
  eind: string;
  lijn1: string;
  lijn2: string;
  end;

var
  BronSub : TStringList;
  HoofdScherm: THoofdScherm;
  MemorySubs: array of SrtRecord;
  BronSubBestand: OrgSub;
  status, StatusSubAfspelen: Integer;
  Subpointer, MovieStatus,SubBestand,SelectSubTijd : string;
  SubLoaded, MovieLoaded, Aangepast, DrawSubItem,TrackBarButtonDown,BronSubLoaded: Boolean;
  GewijzigdBron, GewijzigdSub : Boolean;

implementation

{$R *.dfm}

uses
  StrUtils, DateUtils, Functies, msxml, About, Wijziging;

{ Form events }
procedure THoofdScherm.FormCreate(Sender: TObject);
begin
  SystemParametersInfo(SPI_SETBEEP, 0, nil, SPIF_SENDWININICHANGE);
  //   scripter.Language := slPascal;
  //   scripter.ClearObjects;
  //   scripter.AddAllUnits;
  //   scripter.AddObject('SubRegels',
  //   TListView_sw.ToVar(Regelslijst));
  // TMemo_sw.ToVar(SubRegels));

end;

procedure THoofdScherm.OrgineleSubLaden(bestand: string);
var
  num :Integer;
  LeesRegels: TextFile;
  LeesLijn, temp: string;
begin
  if High(BronSubBestand) > 0 then
    begin
      SetLength(BronSubBestand,0);
    end;

  BronSubLoaded := False;

  try
    assignfile(LeesRegels, Bestand);
    reset(LeesRegels);

    num := 1;
    while not EOF(LeesRegels) Do
      begin
        readln(Leesregels,LeesLijn);

        if Trim(LeesLijn) = IntToStr(num) then
          Inc(num);
      end;

    // Verleng de dynamische array om alles erin te gooien
    SetLength(BronSubBestand,num+1);
    CloseFile(LeesRegels);

    // Nog een keer !
    assignfile(LeesRegels,Bestand);
    reset(LeesRegels);

    num := 1;
    while not EOF(LeesRegels) Do
      begin
        readln(Leesregels,LeesLijn);

        if Trim(LeesLijn) = IntToStr(num) then
          begin
            // het nummer
            BronSubBestand[num].nr := StrToInt(LeesLijn);
            // Lees de tijdregel
            readln(Leesregels,LeesLijn);
            // begintijd
            BronSubBestand[num].start := leftstr(LeesLijn,12);
            // Eindtijd
            BronSubBestand[num].eind := rightstr(LeesLijn,12);
            readln(Leesregels,LeesLijn);

            // eerste regel toevoegen
            BronSubBestand[num].lijn1 := LeesLijn;
            // Lees eventueel de 2de regel
            readln(Leesregels,LeesLijn);

            if (LeesLijn <> '') then
              begin
                Temp := LeesLijn;
                // Lees eventueel de 3de regel
                Readln(LeesRegels,leeslijn);

                if (LeesLijn <> '') then
                  begin
                    Temp := Temp + ' ' + LeesLijn;
                    BronSubBestand[num].lijn2 := temp;
                  end
                else
                  begin
                    BronSubBestand[num].lijn2 := temp;
                  end;
              end
            else
              begin
                BronSubBestand[num].lijn2 := '';
              end;
          end;
          Inc(num);
      end;
      BronSubLoaded := true;
  finally
    CloseFile(LeesRegels);
    GewijzigdBron := false;
  end;
end;

procedure THoofdScherm.FormShow(Sender: TObject);
begin
   SubLoaded := False;
   MovieLoaded := False;

   StatusBuild.Caption := VersieInfo.FileVersion;
   LaadUserInstellingen;
   LaadBookMarks;
   //Devixl Start diversen auto dingen
   if AutoOpslaanCombo.ItemIndex = 0 then AutoOpslaan.Enabled := False;
   //Functies.LaadBWSProjectBestand;
end;

procedure THoofdScherm.FormClose(Sender: TObject; var Action: TCloseAction);
begin


  OpslaanUserInstellingen;
  SystemParametersInfo(SPI_SETBEEP, 1, nil, SPIF_SENDWININICHANGE);
end;

procedure THoofdScherm.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
var
  eResult : TModalResult;
begin
     if GewijzigdSub then
        eResult := MessageDlg('Ondertitel is gewijzigd, opslaan voor het afsluiten?' + Chr(13) + SubBestand,mtConfirmation,mbYesNoCancel,0);
     if eResult = mrCancel then
        CanClose := False
     else if eResult = mrYes then
        OpslaanalsSrt1.Click
     else if eResult = mrNo then
      begin
        CanClose := True;
      end;
end;

procedure THoofdScherm.VerwijderDynElement(var X: OrgSub; Index: Integer);
begin
  inc(index);

  if ((Index < Low(X)) or (Index > High(X))) then Exit;
  if Index < High(X) then
  begin
   Move(X[Succ(Index)], X[Index], Pred(Length(X) - Index) * SizeOf(orgrecord));
   SetLength(X, High(X));
  end;
end;

{           Key events           }
procedure THoofdScherm.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
    //CTRL + <enter> Regel terug
    if (ssCtrl in Shift) and (Key = $0D)  then
    begin
      RegelsLijst.SetFocus;
      if RegelsLijst.ItemIndex > 0 then
      begin
       if RegelsLijst.Items.Count > 1 then
       begin
        RegelsLijst.ItemIndex := RegelsLijst.ItemIndex - 1;
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].MakeVisible(true);
       end;
      end;
    end;
    //Shift + <Enter> regel verder
    if (ssShift in Shift) and (Key = $0D)  then
    begin
      RegelsLijst.SetFocus;
      if RegelsLijst.Items.Count > 1 then
      begin
       if RegelsLijst.ItemIndex < RegelsLijst.Items.Count -1 then
       begin
         RegelsLijst.ItemIndex := RegelsLijst.ItemIndex + 1;
         RegelsLijst.Items.Item[RegelsLijst.ItemIndex].MakeVisible(true);
       end;
       end;
    end;
    //CTRL + R naar de regelslijst !
    if (ssCtrl in Shift) and (Key = $52)  then
    begin
      RegelsLijst.SetFocus;
    end;
    //CTRL + B Bookmarken
    if (ssCtrl in Shift) and (Key = $42)  then
    begin
      if RegelsLijst.ItemIndex <> -1 then
      begin
        // RegelsLijst.Items.Item[RegelsLijst.ItemIndex].ImageIndex := 44;
      end;
    end;

    //CTRL + SHIFT + L speel Video met geselecteerde sub
    if (ssCtrl in Shift) and (ssShift in Shift) and (Key = $4C)  then
    begin
      if (MovieLoaded = True) and (RegelsLijst.ItemIndex <> -1) then
      begin
        SpeelVideoMetGeselecteerdeSub;
        if lbltijd.Blinking then
        begin
         lbltijd.Blinking := false;
        end;
      end;
    end;
    //CTRL + Spatie  Video afspelen / PAuse
    if (ssCtrl in Shift) and (Key = VK_SPACE)  then
    begin
     if (MovieLoaded = True) then
      begin
        RzToolButton1.Click;
      end;
    end;
    //CTRL + O Openen van de srt bestand
    if (ssCtrl in Shift) and (Key = $4F)  then
    begin
        OpenenToolButton.Click;
    end;
    //CTRL + S Opslaan van de huidige Sub
    if (ssCtrl in Shift) and (Key = $4F)  then
    begin
        Opslaan1.Click;
    end;
    //CTRL + Links Video rewind - > MS
    if (ssCtrl in Shift) and (Key = $25)  then
    begin
        if eregel1.Focused or eRegel2.Focused then
        begin
          RegelsLijst.SetFocus;
          Rewind.Click;
        end
        else
        begin
          Rewind.Click;
        end;
    end;
    //CTRL + Rechts Video forward - > Ms
    if (ssCtrl in Shift) and (Key = $27)  then
    begin
        if eregel1.Focused or eRegel2.Focused then
        begin
          RegelsLijst.SetFocus;
          Forward.Click;
        end
        else
        begin
          Forward.Click;
        end;
    end;
    //CTRL + P Openen van de video
    if (ssCtrl in Shift) and (Key = $50)  then
    begin
        OpenVideo.Click;
    end;
    //CTRL + SHIFT + N Schuif sub naar achteren in XMS
    if (ssCtrl in Shift) and (ssShift in Shift) and (Key = $4E)  then
    begin
       if RegelsLijst.ItemIndex <>-1 then
       begin
        VerplaatsSub('Achteruit');
       end;
    end;
    //CTRL + SHIFT + H schuif sub naar voren in XMS
    if (ssCtrl in Shift) and (ssShift in Shift) and (Key = $48)  then
    begin
       if RegelsLijst.ItemIndex <>-1 then
       begin
        VerplaatsSub('Vooruit');
       end;
    end;
    //CTRL + SHIFT + B Begintijd naar voren
    if (ssCtrl in Shift) and (ssShift in Shift) and (Key = $42)  then
    begin
       if RegelsLijst.ItemIndex <>-1 then
       begin
        VerplaatsSub('BeginVooruit');
       end;
    end;
     //CTRL + SHIFT + G Begintijd naar achteren
    if (ssCtrl in Shift) and (ssShift in Shift) and (Key = $47)  then
    begin
       if RegelsLijst.ItemIndex <>-1 then
       begin
        VerplaatsSub('BeginAchteruit');
       end;
    end;
    //CTRL + SHIFT + M Eindtijd naar voren
    if (ssCtrl in Shift) and (ssShift in Shift) and (Key = $47)  then
    begin
       if RegelsLijst.ItemIndex <>-1 then
       begin
        VerplaatsSub('EindVooruit');
       end;
    end;
    //CTRL + SHIFT + J Eindtijd naar achteren
    if (ssCtrl in Shift) and (ssShift in Shift) and (Key = $47)  then
    begin
       if RegelsLijst.ItemIndex <>-1 then
       begin
        VerplaatsSub('EindAchteruit');
       end;
    end;
    //CTRL + K regel erna samenvoegen
    if (ssCtrl in Shift) and (Key = $4B) then
    begin
      Metregelerna1.Click;
    end;
    //CTRL + L regel ervoor samenvoegen
    if (ssCtrl in Shift) and (Key = $4C) then
    begin
      Metregelervoor1.Click;
    end;
end;


{ RzToolButton(1-2-3-4) events }
procedure THoofdScherm.RzToolButton1Click(Sender: TObject);
begin
 With Video do begin
  With lbltijd do begin
   case Ord(PlayerState) of
    1..2:
    begin
         if SubLoaded then
         begin
           SpeelVideoMetSubs;
           status := 0;
         end;
         RunPlayer;
         if Blinking then
         begin
           Blinking := false;
         end;
          RzToolButton1.ImageIndex := 9;
     end;
    3:
    begin
          PausePlayer;
          Blinking := True;
          RzToolButton1.ImageIndex := 10;
     end;
   end;
  end;
 end;
end;

procedure THoofdScherm.RzToolButton2Click(Sender: TObject);
begin
   lbltijd.Blinking := True;
end;

procedure THoofdScherm.RzToolButton3Click(Sender: TObject);
begin
   tmrVideoSub.Enabled := False;
   Video.StopPlayer;
end;

procedure THoofdScherm.RzToolButton4Click(Sender: TObject);
begin
  CheckSub;
end;


{ RzSpinButtons(1-2-3) events }
procedure THoofdScherm.MapOpslaanButtonClick(Sender: TObject);
begin
  if AutoSelectFolder.Execute then
  begin
    AutoMap.Text := AutoSelectFolder.SelectedPathName;
  end;
end;

procedure THoofdScherm.RzSpinButtons1DownLeftClick(Sender: TObject);
var
  regelsItem: TListItem;
begin
  if StartTijd.Text <> '' then
    begin
      StartTijd.EditText := TijdAanpassen(StartTijd.Text,StrToInt('-'+tijdvar.Text));
      if RegelsLijst.ItemIndex <> -1 then
        begin
          regelsItem := RegelsLijst.Items.Item[RegelsLijst.ItemIndex];
          with regelsItem do begin
          SubItems[1] := StartTijd.Text;
          SubItems[3] := UpdateLengte(SubItems[1], SubItems[2]);
          LengteTijd.EditText := UpdateLengte(SubItems[1],SubItems[2]);

            if ((Index > 0) AND (StrToTime(RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems[2]) >= StrToTime(StartTijd.Text))) then
              begin
                RegelsLijst.Items.Item[RegelsLijst.ItemIndex - 1].ImageIndex := 49;
              end;
          end;
        end;
    end;
end;

procedure THoofdScherm.RzSpinButtons1UpRightClick(Sender: TObject);
begin
   if StartTijd.Text <> '' then
   begin
    if ConverteerTijdNaarNano( TijdAanpassen(StartTijd.Text,StrToInt(tijdvar.Text))) > ConverteerTijdNaarNano(EindTijd.Text) then
    begin
      ShowMessage('Begin tijd moet voor de eind tijd zijn.');
      Exit;
    end;

    StartTijd.EditText :=  TijdAanpassen(StartTijd.Text,StrToInt(tijdvar.Text));
    with RegelsLijst do begin
      if ItemIndex <> -1 then
      begin
        Items.Item[ItemIndex].SubItems[1] := StartTijd.Text;
        Items.Item[ItemIndex].SubItems[3] := UpdateLengte(Items.Item[ItemIndex].SubItems[1],Items.Item[ItemIndex].SubItems[2]);
        LengteTijd.EditText := UpdateLengte(Items.Item[ItemIndex].SubItems[1],Items.Item[ItemIndex].SubItems[2]);
      end;
    end;
   end;
end;

procedure THoofdScherm.RzSpinButtons2DownLeftClick(Sender: TObject);
begin
     if EindTijd.Text <> '' then
     begin
      if ConverteerTijdNaarNano(TijdAanpassen(EindTijd.Text,StrToInt('-'+tijdvar.Text))) < ConverteerTijdNaarNano(StartTijd.Text) then
      begin
        ShowMessage('Begin tijd moet voor de eind tijd zijn.');
        Exit;
      end;

      EindTijd.EditText := TijdAanpassen(EindTijd.Text,StrToInt('-'+tijdvar.Text));
      if RegelsLijst.ItemIndex <> -1 then
      begin
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2] := EindTijd.Text;
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2]);
        LengteTijd.EditText := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2]);
      end;
     end;
end;

procedure THoofdScherm.RzSpinButtons2UpRightClick(Sender: TObject);
begin
     if EindTijd.Text <> '' then
     begin
      EindTijd.EditText := TijdAanpassen(EindTijd.Text,StrToInt(tijdvar.Text));
      if RegelsLijst.ItemIndex <> -1 then
      begin
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2] := EindTijd.Text;
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2]);
        LengteTijd.EditText := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2]);
      end;
     end;
end;

procedure THoofdScherm.RzSpinButtons3DownLeftClick(Sender: TObject);
begin
     if LengteTijd.Text <> '' then
     begin
      if ConverteerTijdNaarNano(LengteTijd.Text) < (StrToInt64(tijdvar.Text) * 10000) then
      begin
        ShowMessage('Begin tijd moet voor de eind tijd zijn.');
        Exit;
      end;

      LengteTijd.EditText := TijdAanpassen(LengteTijd.Text,StrToInt('-'+tijdvar.Text));
      EindTijd.EditText := TijdAanpassen(EindTijd.Text,StrToInt('-'+tijdvar.Text));

      if RegelsLijst.ItemIndex <> -1 then
      begin
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2] := EindTijd.Text;
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2]);
      end;
     end;
end;

procedure THoofdScherm.RzSpinButtons3UpRightClick(Sender: TObject);
begin
     if LengteTijd.Text <> '' then
     begin
      LengteTijd.EditText := TijdAanpassen(LengteTijd.Text,StrToInt('+'+tijdvar.Text));
      EindTijd.EditText := TijdAanpassen(EindTijd.Text,StrToInt('+'+tijdvar.Text));

      if RegelsLijst.ItemIndex <> -1 then
      begin
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2] := EindTijd.Text;
        RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2]);
      end;
     end;
end;


{ eRegel(1-2) events }
procedure THoofdScherm.eRegelKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
var
  veldEdit: TEdit;
  cursorPositieRegel1: Integer;
  huidigeRegel: TListItem;
begin
  veldEdit := Sender as TEdit;

  // Shift + spatie && Shift + <enter>
  if ((ssCtrl in Shift) and (Key = VK_SPACE)) or ((ssCtrl in Shift) and (Key = $0D))  then
    begin
      veldEdit.ReadOnly := True;
    end;

  if (Sender = eRegel2) then
    begin
      if (Key = VK_BACK) then
        begin

          begin
           huidigeRegel := RegelsLijst.Items.Item[RegelsLijst.ItemIndex];
            //Devixl Fix alleen als cursor op 0 staat terug naar regel 1 zetten.
            if (eRegel2.SelStart = 0) and (eRegel2.SelLength = 0) then
            begin
              cursorPositieRegel1 := eRegel1.GetTextLen + 1;
              huidigeRegel.SubItems[4] := huidigeRegel.SubItems[4] + ' ' + eRegel2.Text;
              eRegel1.Text := huidigeRegel.SubItems[4];
              eRegel2.Text := '';
              eRegel1.SetFocus;
              eRegel1.SelLength := 0;
              eRegel1.SelStart := cursorPositieRegel1;
            end;
          end;
        end;
    end;
end;

procedure THoofdScherm.eRegel1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
var
  cursorPositie: Integer;
  tekstNaCursor: String;
begin
 With RegelsLijst do begin
  if ItemIndex <> -1 then
    begin
      if SubLoaded then
        begin
          Items.Item[ItemIndex].SubItems[4] := eRegel1.Text;
          GewijzigdSub := True;
        end;

      if (Key = VK_RETURN) then
        begin
          if (eRegel1.GetTextLen > 0) then
            begin
              cursorPositie := eRegel1.SelStart;
              eRegel1.SelLength := eRegel1.GetTextLen - cursorPositie;

              if (eRegel1.SelLength > 0) then
                begin
                  tekstNaCursor := eRegel1.SelText;
                  eRegel1.SelText := '';
                  eRegel1.Text := Trim(eRegel1.Text);
                  eRegel2.Text := Trim(tekstNaCursor + ' ' + eRegel2.Text);
                end;
            end;

          Items.Item[RegelsLijst.ItemIndex].SubItems[4] := eRegel1.Text;
          eRegel2.SetFocus;
          eRegel2.SelLength := 0;
        end;

      if (Key = VK_DOWN) then
        begin
          Items.Item[ItemIndex].SubItems[4] := eRegel1.Text;
          eRegel2.SetFocus;
        end;
     end;

  eRegel1.ReadOnly := False;

 end;
end;

procedure THoofdScherm.eRegel2KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
var
  huidigeRegel: TListItem;
  cursorPositieRegel1: Integer;
begin
  if regelslijst.ItemIndex <> -1 then
    begin
      huidigeRegel := RegelsLijst.Items.Item[RegelsLijst.ItemIndex];

      if SubLoaded then
        begin
          huidigeRegel.SubItems[5] := eRegel2.Text;
          GewijzigdSub := True;
        end;

      if (Key = VK_RETURN) then
        begin
          huidigeRegel.SubItems.Insert(5, eRegel2.Text);
          RegelsLijst.ItemIndex := RegelsLijst.ItemIndex + 1;
          RegelsLijst.Items.Item[RegelsLijst.ItemIndex].MakeVisible(true);
          eRegel1.SetFocus;
        end;

      if (Key = VK_UP) then
        begin
          huidigeRegel.SubItems.Insert(5,eRegel2.Text);
          eRegel1.SetFocus;
        end;

      { The BACKSPACE key will be checked in de KEY_DOWN event,
          otherwise it goes to fast to the previous line! }
    end;

  eRegel2.ReadOnly := False;
  GewijzigdSub := True;
  lblAantalRegel2.Caption := IntToStr(eRegel2.GetTextLen);
end;

procedure THoofdScherm.eRegel1Change(Sender: TObject);
begin
  lblAantalRegel1.Caption := IntToStr(eRegel1.GetTextLen);

  if eRegel2.Text <> '' then
    begin
      SubVideoRegels.Caption := eRegel1.Text + Chr(13) + eRegel2.Text;
    end
  else
    begin
      SubVideoRegels.Caption := eRegel1.Text + Chr(13);
    end;
end;

procedure THoofdScherm.eRegel1Exit(Sender: TObject);
begin
  if SubLoaded then
  begin
   RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[4] := eRegel1.Text;
  end;
end;

procedure THoofdScherm.eRegel2Change(Sender: TObject);
begin
   SubVideoRegels.Caption := eRegel1.Text + Chr(13) + eRegel2.Text;
end;

procedure THoofdScherm.eRegel2Exit(Sender: TObject);
begin
  if SubLoaded then
  begin
   RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Insert(5,eRegel2.Text);
  end;
end;

{ Bookmark(1-2-3-4) events }
procedure THoofdScherm.BookMarkClick(Sender: TObject; ImageIndex: Integer);
var
  BookItem: TListItem;
begin
  if RegelsLijst.ItemIndex <> -1 then
    begin
      if (not RegelHeeftBookMark(RegelsLijst.ItemIndex, ImageIndex)) then
        begin
          BookItem := BookMarks.Items.Add;
          BookItem.ImageIndex := ImageIndex;
          BookItem.Caption := RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[0];
          BookItem.SubItems.Add(AnsiReplaceStr(BookMark1.Caption,'&',''));
          RegelsLijst.Items.Item[RegelsLijst.ItemIndex].ImageIndex := ImageIndex;
          RegelsLijst.Repaint;
        end;
    end;
end;

procedure THoofdScherm.BookMarkLijstMenuChange(Sender: TObject; Source: TMenuItem;
  Rebuild: Boolean);
begin
  if BookMarks.ItemIndex <> -1 then
    BookmarkVerwijderen1.Enabled := true
  else
    BookmarkVerwijderen1.Enabled := false;
end;

procedure THoofdScherm.BookMark1Click(Sender: TObject);
begin
   BookMarkClick(Sender,19);
end;

procedure THoofdScherm.BookMark2Click(Sender: TObject);
begin
   BookMarkClick(sender,20);
end;

procedure THoofdScherm.BookMark3Click(Sender: TObject);
begin
   BookMarkClick(Sender,21);
end;

procedure THoofdScherm.BookMark4Click(Sender: TObject);
begin
   BookMarkClick(Sender,22);
end;

function THoofdScherm.RegelHeeftBookMark(regel, bookmark: Integer): Boolean;
var
  bkm: TListItem;
  i: Integer;
begin
  i := 0;
  Result := false;
  while ((not Result) AND (i < BookMarks.Items.Count)) do
    begin
      bkm := BookMarks.Items.Item[i];
      Result := ((bkm.Caption = IntToStr(regel + 1)) AND (bkm.ImageIndex = bookmark));
      inc(i);
    end;
end;

procedure THoofdScherm.BookMarksSelectItem(Sender: TObject; Item: TListItem; Selected: Boolean);
begin
  if BookMarks.ItemIndex <> -1 then
  begin
    RegelsLijst.ItemIndex := StrToInt(BookMarks.Items.Item[BookMarks.ItemIndex].Caption)- 1;
    RegelsLijst.Items.Item[RegelsLijst.ItemIndex].MakeVisible(true);
  end;
end;

procedure THoofdScherm.VerwijderBookMark1Click(Sender: TObject);
var
  regelBookmarkItem, bookmark: TListItem;
begin
  if BookMarks.ItemIndex <> -1 then
  begin
    regelBookmarkItem := BookMarks.Items.Item[BookMarks.ItemIndex];
    RegelsLijst.Items.Item[StrToInt(regelBookmarkItem.Caption) - 1].ImageIndex := -1;

    for bookmark in BookMarks.Items do
      begin
        if (bookmark.Caption = regelBookmarkItem.Caption) AND (bookmark.Index <> regelBookmarkItem.Index) then
          RegelsLijst.Items.Item[StrToInt(regelBookmarkItem.Caption) - 1].ImageIndex := bookmark.ImageIndex;
      end;

    regelBookmarkItem.Delete;
  end;
end;

procedure THoofdScherm.VerwijderBookmark2Click(Sender: TObject);
var
  selectedItem, bookmark: TListItem;
begin
  if RegelsLijst.ItemIndex <> -1 then
    begin
      selectedItem := RegelsLijst.Items.Item[RegelsLijst.ItemIndex];
      selectedItem.ImageIndex := -1;

      for bookmark in Bookmarks.Items do
        begin
          if (bookmark.Caption = IntToStr(selectedItem.Index + 1)) then
            bookmark.Delete;
        end;
    end;
end;


procedure THoofdScherm.Verwijderen1Click(Sender: TObject);
begin
  RegelVerwijderen.Click;
end;

{ TijdVar events }
procedure THoofdScherm.TijdVarKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
  TijdVar.ReadOnly := True;
end;

procedure THoofdScherm.TijdVarKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
  TijdVar.ReadOnly := false;
end;


{ Regel(s) events }
procedure THoofdScherm.RegelToevoegenClick(Sender: TObject);
var
  Toevoegitem: TListItem;
  i: integer;
begin
  if RegelsLijst.ItemIndex <> -1 then
  begin
    Toevoegitem := RegelsLijst.Items.Insert(RegelsLijst.ItemIndex+1);

    with Toevoegitem do
      begin
        ImageIndex := 31;
        subitems.Add('');
        SubItems.Add(TijdAanpassen(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2],StrToInt('+'+tijdvar.Text)));
        SubItems.Add(TijdAanpassen(RegelsLijst.Items.Item[RegelsLijst.ItemIndex+1].SubItems[1],StrToInt('-'+tijdvar.Text)));
        SubItems.Add(UpdateLengte(SubItems.Strings[1],SubItems.Strings[2]));
        SubItems.Add('');
        SubItems.Add('');
      end;

    for i := 0 to RegelsLijst.Items.Count - 1 do
      begin
        RegelsLijst.Items.Item[i].SubItems.Strings[0] := IntToStr(i+1);
      end;
  end;
end;

procedure THoofdScherm.RegelVerwijderenClick(Sender: TObject);
var
  i: Integer;
begin
  if RegelsLijst.ItemIndex <> -1 then
    begin
      VerwijderDynElement(BronSubBestand, RegelsLijst.ItemIndex);
      RegelsLijst.Items.Delete(RegelsLijst.ItemIndex);

      for i := 0 to RegelsLijst.Items.Count - 1 do
        begin
          RegelsLijst.Items.Item[i].SubItems.Strings[0] := IntToStr(i+1);
        end;
    end;
end;

procedure THoofdScherm.RegelDblClick(Sender: TObject);
begin
  if (RegelsLijst.ItemIndex <> -1) AND (MovieLoaded = true) then
    begin
      SpeelVideoMetGeselecteerdeSub;
      if lbltijd.Blinking then
      begin
          lbltijd.Blinking := false;
      end;
    end;
end;

procedure THoofdScherm.RegelLijstMenuChange(Sender: TObject; Source: TMenuItem;
  Rebuild: Boolean);
begin
  if (RegelsLijst.ItemIndex <> -1) then
    begin
      VerwijderBookmark2.Enabled := RegelsLijst.Items.Item[RegelsLijst.ItemIndex].ImageIndex <> -1;
    end;
end;

procedure THoofdScherm.RegelsLijstSelectItem(Sender: TObject; Item: TListItem; Selected: Boolean);
begin
  eRegel1.Clear;
  eRegel2.Clear;
  OrgRegel1.Clear;
  Orgregel2.Clear;

  if Item.SubItems.Strings[4] <> '' then
    begin
      eRegel1.Text := Item.SubItems.Strings[4];
      lblAantalRegel1.Caption := IntToStr(eRegel1.GetTextLen);
    end;

  if Item.SubItems.Strings[5] <> '' then
    begin
      eRegel2.Text := Item.SubItems.Strings[5];
      lblAantalRegel2.Caption := IntToStr(eRegel2.GetTextLen);
    end
  else
    begin
      lblAantalRegel2.Caption := '0';
    end;

  if Item.SubItems.Strings[1] <> '' then
    begin
      StartTijd.Text := Item.SubItems.Strings[1];
    end;

  if Item.SubItems.Strings[2] <> '' then
    begin
      EindTijd.Text := Item.SubItems.Strings[2];
    end;

  if Item.SubItems.Strings[3] <> '' then
    begin
      LengteTijd.Text := item.SubItems.Strings[3];
    end;

  if BronSubLoaded then
    begin
      OrgRegel1.Text := BronSubBestand[StrToInt(Item.SubItems.Strings[0])].lijn1;
      Orgregel2.Text := BronSubBestand[StrToInt(Item.SubItems.Strings[0])].lijn2;
    end;

  if ToonOrgSub.Checked then
    begin
      SubVideoRegels.Caption := OrgRegel1.Text + Chr(13) + Orgregel2.Text;
    end
  else
    begin
      SubVideoRegels.Caption := eRegel1.Text + Chr(13) + eRegel2.Text;
    end;
end;

procedure THoofdScherm.RegelsLijstKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
  if (Key = VK_RETURN) then
    begin
      eRegel1.SetFocus;
    end;
end;

procedure THoofdScherm.RegelsLijstChange(Sender: TObject; Item: TListItem;
  Change: TItemChange);
begin
  BookMark5.Enabled := true;
end;

procedure THoofdScherm.RegelsLijstCustomDrawSubItem(Sender: TCustomListView; Item: TListItem;
    SubItem: Integer; State: TCustomDrawState; var DefaultDraw: Boolean);
begin
  //Devixl Fix in het ophalen van de lengte
  if Length(Item.SubItems.Strings[4]) > StrToInt(LengteRegels.Text) then
    begin
      RegelsLijst.Canvas.Font.Color := clred;
    end;
end;

{ ToolButton(2-4) events }
procedure THoofdScherm.OpenenToolButtonClick(Sender: TObject);
begin
   SubBestand := '';
   if OpenSrtBestand.Execute then
   begin
      SrtBestandLaden(OpenSrtBestand.FileName);
    end;
end;

procedure THoofdScherm.ToolButton4Click(Sender: TObject);
begin
   Form2.Show;
  //ShowMessage(GetWindowsLanguage);
end;


{ Opslaan events }
procedure THoofdScherm.OpslaanalsSrt1Click(Sender: TObject);
var
  i: Integer;
  SrtBestand: TextFile;
begin
  if SaveSrtDialog.Execute then
  begin
    try
     AssignFile(SrtBestand,SaveSrtDialog.FileName);
     Rewrite(SrtBestand);
      for i := 0 to RegelsLijst.Items.Count - 1 do
      begin
          Writeln(Srtbestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[0]));
          writeln(SrtBestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[1]+' --> '+RegelsLijst.Items.Item[i].SubItems.Strings[2]));
          writeln(SrtBestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[4]));

          if RegelsLijst.Items.Item[i].SubItems.Strings[5] <> '' then
          begin
           Writeln(SrtBestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[5]));
          end;

          Writeln(SrtBestand,string(''));
      end;
    finally
     CloseFile(SrtBestand);
     if GewijzigdSub then GewijzigdSub := false;
     // SaveRegels.Free;
    end;
  end;
end;

procedure THoofdScherm.Opslaanorginelesub1Click(Sender: TObject);
var
  i: Integer;
  SrtBestand: TextFile;
begin
  if SaveSrtDialog.Execute then
  begin
    try
     AssignFile(SrtBestand,SaveSrtDialog.FileName);
     Rewrite(SrtBestand);
      for i := 1 to High(BronSubBestand) do
      begin
          Writeln(Srtbestand,string(IntToStr(BronsubBestand[i].nr)));
          writeln(SrtBestand,string(BronSubBestand[i].start+' --> '+BronSubBestand[i].eind));
          writeln(SrtBestand,string(BronSubBestand[i].lijn1));

          if BronSubBestand[i].lijn2 <> '' then
          begin
           Writeln(SrtBestand,string(BronSubBestand[i].lijn2));
          end;

          Writeln(SrtBestand,string(''));
      end;
    finally
     CloseFile(SrtBestand);
     // SaveRegels.Free;
    end;
  end;
end;

procedure THoofdScherm.Opslaan1Click(Sender: TObject);
var
  i: Integer;
  SrtBestand: TextFile;
begin
 if SubBestand <> '' then
 begin
  if (AutoOpslaan.Enabled = true) and (AutoMap.Text <> '') then
  begin
    SubBestand := AutoMap.Text + ExtractFileName(SubBestand);
  end;
  try
     AssignFile(SrtBestand,SubBestand);
     Rewrite(SrtBestand);
      for i := 0 to RegelsLijst.Items.Count - 1 do
      begin
          Writeln(Srtbestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[0]));
          writeln(SrtBestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[1]+' --> '+RegelsLijst.Items.Item[i].SubItems.Strings[2]));
          writeln(SrtBestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[4]));

          if RegelsLijst.Items.Item[i].SubItems.Strings[5] <> '' then
          begin
           Writeln(SrtBestand,string(RegelsLijst.Items.Item[i].SubItems.Strings[5]));
          end;

          Writeln(SrtBestand,string(''));
      end;
      ShowMessage('Bestand is opgeslagen');
   finally
      CloseFile(SrtBestand);
      GewijzigdSub := False;
  //    SaveRegels.Free;
   end;
 end;
end;

procedure THoofdScherm.OpslaanalsBWSproject1Click(Sender: TObject);
begin
  OpslaanBWSProjectBestand;
end;


{ Openen events }
procedure THoofdScherm.Openbronsub1Click(Sender: TObject);
begin
 if OpenSrtBestand.Execute then
 begin
   OrgineleSubLaden(OpenSrtBestand.FileName);
 end;
end;

procedure THoofdScherm.OpenVideoClick(Sender: TObject);
begin
    if OpenVideoBestand.Execute then
    begin
      Video.PlayerFileName := OpenVideoBestand.FileName;
      video.OpenPlayer;
      lblTijd.Caption := '00:00:00,00 / ' + SecToTime(Video.PlayerDuration div 10000000);
      FilmNaam.Caption := 'Film - ' + Openvideobestand.FileName;
      MovieLoaded := True;
    end;
end;


{ Video events }
procedure THoofdScherm.VideoClick(Sender: TObject);
begin
    RzToolButton1.Click;
end;

procedure THoofdScherm.VideoFrameProgress2(Sender: TObject; FrameInfo: pFrameInfo);
begin
   with FrameInfo^ do
   begin            // Formatting de tijd voor video, Gebruik video pointers voor snellere geheugen toevoer.
     subpointer := Format ('%.2d:%.2d:%.2d,%.2d', [FrameTime_Hour, FrameTime_Min, FrameTime_Sec, FrameTime_Hs]);
     lbltijd.Caption := Format ('%.2d:%.2d:%.2d,%.2d', [FrameTime_Hour, FrameTime_Min, FrameTime_Sec, FrameTime_Hs]) + ' / ' + SecToTime(Video.PlayerDuration div 10000000);
   end;
end;

procedure THoofdScherm.VolumeBarChange(Sender: TObject);
begin
  Video.AudioVolume := VolumeBar.Position;
end;

procedure THoofdScherm.RewindClick(Sender: TObject);
begin
  With video do
  begin
   if PlayerFileName <> '' then
   begin
      PlayerTimePosition := PlayerTimePosition - (StrToInt(TijdVar.Text) * 10000);
   end;
  end;
end;

procedure THoofdScherm.ForwardClick(Sender: TObject);
begin
  With video do
  begin
   if PlayerFileName <> '' then
   begin
      PlayerTimePosition := PlayerTimePosition + (StrToInt(TijdVar.Text) * 10000);
   end;
  end;
end;

procedure THoofdScherm.RefreshTimerTimer(Sender: TObject);
begin
  CheckSub;
end;

{ Timers }
procedure THoofdScherm.tmrVideoSubTimer(Sender: TObject);
var
  i: Integer;
begin
  if ToonOrgSub.Checked then
  begin
  for I := 1 to High(BronSubBestand) do
   begin
     if status = 0 then
      begin
        if AnsiLeftStr(BronSubBestand[i].start,10) = AnsiLeftStr(subpointer,10) then
        begin
          With SubVideoRegels do
          begin
            Caption := '';
            Caption := BronSubBestand[i].lijn1 + #13 + BronSubBestand[i].lijn2;
          end;
          status := 1;
          With RegelsLijst do
          begin
            ItemIndex := i-1;
            Items.Item[i-1].MakeVisible(true);
          end;
        end;
      end
      else if status = 1 then
      begin
        if AnsiLeftStr(BronSubBestand[i].eind,10) = AnsiLeftStr(Subpointer,10) then
        begin
          SubVideoRegels.Caption := '';
          status := 0;
        end;
      end;
   end;

  end
  else
  begin

  for i := 1 to High(MemorySubs) do
    begin
      if status = 0 then
        begin
          if AnsiLeftStr(MemorySubs[i].start,10) = AnsiLeftStr(subpointer,10) then
            begin
              With SubVideoRegels do
              begin
                Caption := '';
                Caption := Memorysubs[i].lijn1 + #13 + Memorysubs[i].lijn2;
              end;
              status := 1;
              With RegelsLijst do
              begin
                ItemIndex := i-1;
                Items.Item[i-1].MakeVisible(true);
              end;
            end;
        end
      else if status = 1 then
        begin
          if AnsiLeftStr(MemorySubs[i].eind,10) = AnsiLeftStr(Subpointer,10) then
            begin
              SubVideoRegels.Caption := '';
              status := 0;
            end;
        end;
    end;
  end;
end;

procedure THoofdScherm.SelectSubTimerTimer(Sender: TObject);
begin
  if AnsiLeftStr(subpointer,10) = SelectSubTijd then
  begin
     Video.PausePlayer;
     SelectSubTimer.Enabled := False;
  end;
end;

procedure THoofdScherm.AutoOpslaanComboChange(Sender: TObject);
begin
 With AutoOpslaan do begin
   if AutoOpslaanCombo.ItemIndex = 0 then
   begin
    Enabled := False;
   end
   else
   begin
    Interval := StrToInt(AutoOpslaanCombo.Text) * 60000;
    Enabled := True;
   end;
 end;
end;

procedure THoofdScherm.AutoOpslaanTimer(Sender: TObject);
begin
   if SubLoaded then
      Opslaan1.Click;
end;

procedure THoofdScherm.IFontVideoChange(Sender: TObject);
begin
  VeranderFontVideo;
end;

// Naar de regel toe :)
procedure THoofdScherm.infoClick(Sender: TObject);
var
   i: integer;
begin
  if ((info.Items.Count > 0) AND (info.Selected <> nil)) then
  begin
   if (not AnsiContainsStr(info.Selected.Text,'|')) or (info.Items.Count = 0) or (info.Selected.IsFirstNode) then
   begin
     Exit;
   end
   else
   begin
     with RegelsLijst do
     begin
      i := AnsiPos('|',info.Selected.Text);
      ItemIndex := StrToInt(AnsiLeftStr(info.Selected.Text,i-1))-1;
      Items.Item[ItemIndex].MakeVisible(true);
      end;
   end;
  end;
end;

procedure THoofdScherm.Metregelerna1Click(Sender: TObject);
var
  i, OrgRegel,DesRegel : integer;
  temp,temp2,temporg,temporg2,tijd1,tijd2: string;
begin
    if RegelsLijst.ItemIndex < RegelsLijst.Items.Count -1 then
    begin
       //Devixl Schoner :)
       OrgRegel := RegelsLijst.ItemIndex;
       DesRegel := RegelsLijst.ItemIndex+1;

       temp := RegelsLijst.Items.Item[OrgRegel].SubItems.Strings[4]+ ' ' + RegelsLijst.Items.Item[DesRegel].SubItems.Strings[4];
       //Bronsub mag ook meedoen
       if BronSubLoaded then
       temporg := Bronsubbestand[OrgRegel].lijn1 + ' ' + Bronsubbestand[DesRegel].lijn1;

       if RegelsLijst.Items.Item[OrgRegel].SubItems.Strings[5] <> '' then
       begin
          temp2 := RegelsLijst.Items.Item[OrgRegel].SubItems.Strings[5]+ ' '+ RegelsLijst.Items.Item[DesRegel].SubItems.Strings[5];
       end;

       if BronSubLoaded then
       begin
         if BronSubBestand[OrgRegel].lijn2 <> '' then
         begin
            temporg2 := BronSubbestand[OrgRegel].lijn2 + ' ' + bronsubbestand[DesRegel].lijn2;
         end;
       end;

      tijd1 := RegelsLijst.Items.Item[OrgRegel].SubItems.Strings[1];
      tijd2 := RegelsLijst.Items.Item[RegelsLijst.ItemIndex+1].SubItems.Strings[2];

      RegelsLijst.Items.Item[DesRegel].SubItems.Strings[1]:= tijd1;
      RegelsLijst.Items.Item[DesRegel].SubItems.Strings[2] := tijd2;
      RegelsLijst.Items.Item[DesRegel].SubItems.Strings[3] := UpdateLengte(tijd1,tijd2);

      RegelsLijst.Items.Item[DesRegel].SubItems.Strings[4] := temp;

      if BronSubLoaded then
      VerwijderDynElement(BronSubBestand,OrgRegel);

      if BronSubLoaded then
       BronSubBestand[DesRegel].lijn1 := temporg;

       //Extra check :)
       if temp2 <> '' then
       begin
         RegelsLijst.Items.Item[DesRegel].SubItems.Strings[5] := temp2;
         BronSubBestand[DesRegel].lijn2 := temporg2;
       end;

       //Bronsub ook updaten
       if BronSubLoaded then
       begin
        BronSubBestand[DesRegel].start := tijd1;
        BronSubBestand[DesRegel].eind := tijd2;
       end;
      // Eerst de regel uit de bronsub weggooien, anders is de itemindex weg = -1

       RegelsLijst.Items.Delete(OrgRegel);
       //rebuild de nummering
        for i := 0 to RegelsLijst.Items.Count - 1 do
        begin
          RegelsLijst.Items.Item[i].SubItems.Strings[0] := IntToStr(i+1);
        end;

       GewijzigdSub := True;
    end;
end;

procedure THoofdScherm.Metregelervoor1Click(Sender: TObject);
var
  i : integer;
  temp,temp2,temporg,temporg2,tijd1,tijd2: string;
begin
    if RegelsLijst.ItemIndex > 1 then
    begin
       temp := RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[4]+ ' ' + RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[4];

       if BronSubLoaded then
       temporg := Bronsubbestand[RegelsLijst.ItemIndex].lijn1 + ' ' + Bronsubbestand[RegelsLijst.ItemIndex-1].lijn1;

       if RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[5] <> '' then
       begin
          temp2 := RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[5]+ ' '+ RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[5];
       end;

       if BronSubLoaded then
       begin
         if BronSubBestand[RegelsLijst.ItemIndex].lijn2 <> '' then
         begin
            temporg2 := BronSubbestand[RegelsLijst.ItemIndex].lijn2 + ' ' + bronsubbestand[RegelsLijst.ItemIndex-1].lijn2;
         end;
       end;

       tijd1 := RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[1];
       tijd2 := RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2];

       RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[1] := tijd1;
       RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[2] := tijd2;
       RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[3] := UpdateLengte(tijd1,tijd2);


       RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[4] := temp;

       if BronSubLoaded then
       BronSubBestand[RegelsLijst.ItemIndex-1].lijn1 := temporg;

       if temp2 <> '' then
       begin
         RegelsLijst.Items.Item[RegelsLijst.ItemIndex-1].SubItems.Strings[5] := temp2;
         BronSubBestand[RegelsLijst.ItemIndex-1].lijn2 := temporg2;
       end;

       if BronSubLoaded then
       begin
         BronSubBestand[RegelsLijst.ItemIndex-1].start := tijd1;
         BronSubBestand[RegelsLijst.ItemIndex-1].eind := tijd2;
       end;

       VerwijderDynElement(BronSubBestand,RegelsLijst.ItemIndex);
       RegelsLijst.Items.Delete(RegelsLijst.ItemIndex);

        for i := 0 to RegelsLijst.Items.Count - 1 do
        begin
          RegelsLijst.Items.Item[i].SubItems.Strings[0] := IntToStr(i+1);
        end;

        GewijzigdSub := True;
    end;
end;

{ PROCEDURES }
procedure THoofdScherm.SrtBestandLaden(Bestand: string);
var
  LeesRegels: TextFile;
  Regel: TListItem;
  LeesLijn, Temp: string;
  num, RegelExtra, i: Integer;
  RootNode, Node: TTreeNode;
  ExtraLijst, RegelsTeLang: TStringList;
begin
  num := 1;
  RegelExtra := 0;

  if not FileExists(Bestand) then
  begin
     ShowMessage('Kan gekozen bestand niet vinden - ' + bestand);
  end;
  RegelsLijst.Items.Clear;
  info.Items.Clear;
    try
      ExtraLijst := TStringList.Create;
      RegelsTeLang := TStringList.Create;

      assignfile(LeesRegels,Bestand);
      reset(LeesRegels);

      RegelsLijst.Items.BeginUpdate;
      while not EOF(LeesRegels) Do begin;

       readln(Leesregels,LeesLijn);
       if Trim(LeesLijn) = IntToStr(num) then begin

          Regel := RegelsLijst.Items.add;

          with Regel do begin
            ImageIndex := -1;
            Caption := '';
            // het nummer
            SubItems.Add(Leeslijn);
            // Lees de tijdregel
            readln(Leesregels,LeesLijn);
            // begintijd
            SubItems.Add(leftstr(LeesLijn,12));
            // Eindtijd
            SubItems.Add(rightstr(LeesLijn,12));
            // Lengte
            SubItems.Add(UpdateLengte(rightstr(LeesLijn,12),leftstr(LeesLijn,12)));

            // lees de eerste tekst regel
            readln(Leesregels,LeesLijn);

            if Length(LeesLijn) > strtoint(LengteRegels.Text) then
            begin
              RegelsTeLang.Add(IntToStr(num)+'|'+ LeesLijn);
            end;
            // eerste regel toevoegen
            SubItems.Add(LeesLijn);
            // Lees eventueel de 2de regel
            readln(Leesregels,LeesLijn);

              if (LeesLijn <> '') then begin
                 Temp := LeesLijn;
                 // Lees eventueel de 3de regel
                 Readln(LeesRegels,leeslijn);
                 if (LeesLijn <> '') then begin
                   RegelExtra := RegelExtra + 1;
                   ExtraLijst.Add(IntToStr(num)+'|'+leeslijn);
                   Temp := Temp + ' ' + LeesLijn;
                   SubItems.Add(temp);
                   ImageIndex := 50;
                 end
                 else
                 begin
                   SubItems.Add(temp);
                 end;
              end
              else
              begin
                SubItems.Add('');
              end;
        end;
         Inc(num);
       end;

     end;

     RegelsLijst.Items.EndUpdate;

     SubLoaded := True;

     CloseFile(LeesRegels);

     SubBestand := Bestand;
     // De zooi enablen na het laden van de sub
     RzSpinButtons1.Enabled := True;
     RzSpinButtons2.Enabled := True;
     RzSpinButtons3.Enabled := True;

     //Orginele Sub laden in de mem
    // OrgineleSubLaden;
       //Opslaan gedeelte
     SaveButton.Enabled := True;

    // Sum up de dingen die we zijn tegengekomen :)
       Rootnode := info.Items.Add(nil,'Info');
       RootNode.ImageIndex := 28;
       RootNode.SelectedIndex := 28;

       Node := info.Items.AddChild( RootNode, 'Aantal regels: '+ IntToStr(RegelsLijst.Items.Count));
       Node.ImageIndex := 47;
       Node.SelectedIndex := 47;

       if RegelExtra > 0 then
       begin
           rootnode := info.Items.Add(nil,'Regels samengevoegd ('+ IntToStr(RegelExtra)+')');
           RootNode.ImageIndex := 15;
           RootNode.SelectedIndex := 15;
           for i := 0 to RegelExtra - 1 do
           begin
              Node := info.Items.AddChild(RootNode, ExtraLijst.Strings[i]);
              Node.ImageIndex := 47;
              Node.SelectedIndex := 47;
           end;
       end;

       if RegelsTeLang.Count > 0 then
       begin
          rootnode := info.Items.Add(nil,'Regels te lang ('+inttostr(RegelsTeLang.Count)+')');
          RootNode.ImageIndex := 16;
          RootNode.SelectedIndex := 16;
          for i := 0 to RegelsTeLang.Count - 1 do
           begin
              Node := info.Items.AddChild(RootNode, RegelsTeLang.Strings[i]);
              Node.ImageIndex := 47;
              Node.SelectedIndex := 47;
           end;
       end;
       RegelsTeLang.Free;
       ExtraLijst.Free;
       HoofdScherm.Caption := Programma + ' - '+ Bestand;
       //info.FullExpand;
       GewijzigdSub := False;
    except
     ShowMessage('Deze Sub wordt niet ondersteunt, kijk of meld deze op het forum.' +chr(13)+chr(10)+'Of ze de datumnotatie in windows op NL.');
     CloseFile(LeesRegels);
    end;
end;

procedure THoofdScherm.ToonSub;
begin
  // Nog te implementeren ?
  // Ja, maar wat ?
end;

procedure THoofdScherm.SpeelVideoMetSubs;
var
  i: integer;
begin
  SetLength(MemorySubs,regelslijst.Items.Count+1);
  // Laad alle regeltjes in het MEMORY
  for i := 1 to RegelsLijst.Items.count do
    begin
      MemorySubs[i].nr := StrToInt(RegelsLijst.Items.Item[i-1].SubItems.Strings[0]);
      MemorySubs[i].start := RegelsLijst.Items.Item[i-1].SubItems.Strings[1];
      MemorySubs[i].eind := RegelsLijst.Items.Item[i-1].SubItems.Strings[2];
      MemorySubs[i].lijn1 := RegelsLijst.Items.Item[i-1].SubItems.Strings[4];

      if RegelsLijst.Items.Item[i-1].SubItems.Count = 6 then
        begin
          MemorySubs[i].lijn2 := RegelsLijst.Items.Item[i-1].SubItems.Strings[5];
        end;
    end;

    if not tmrVideoSub.Enabled then
      begin
        tmrVideoSub.Enabled := True;
      end;
end;

procedure THoofdScherm.SpeelVideoMetGeselecteerdeSub;
var
  a: Int64;
begin
  if tmrVideoSub.Enabled then
    begin
      tmrVideoSub.Enabled := False;
    end;

  if RegelsLijst.ItemIndex <> -1 then
    begin

      StatusSubAfspelen := 1;
      a:= ConverteerTijdNaarNano(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[1]);
      SelectSubTijd := AnsiLeftStr(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems[2],10);

      video.OpenPlayerAtTimePositions(a,0,False,false);
      SubVideoRegels.Caption := '';

      if ToonOrgSub.Checked then
      begin
        SubVideoRegels.Caption := OrgRegel1.Text + #13 + Orgregel2.Text;
      end
      else
      begin
        SubVideoRegels.Caption := eRegel1.Text + #13 + eRegel2.Text;
      end;

      if RzToolButton1.ImageIndex = 10 then
         RzToolButton1.ImageIndex := 9;

      Video.RunPlayer;

      SelectSubTimer.Enabled:= True;

    end;
end;

procedure THoofdScherm.CheckSub;
var
  i, z: integer;
  RootNode, Node: TTreeNode;
  ExtraLijst, RegelsTeLang: TStringList;
begin
   if not SubLoaded then
     begin
       Exit;
     end;
    try
     info.Items.Clear;
     ExtraLijst := TStringList.Create;
     RegelsTeLang := TStringList.Create;

     for z := 0 to RegelsLijst.Items.Count - 1 do
     begin
       if Length(RegelsLijst.Items.Item[z].SubItems[4]) > strtoint(LengteRegels.Text) then
       begin
          RegelsTeLang.Add(IntToStr(z+1)+'|'+Regelslijst.Items.Item[z].SubItems.Strings[4]);
       end;

       if RegelsLijst.Items.Item[z].ImageIndex = 50 then
       begin
         ExtraLijst.Add(IntToStr(z+1)+'|'+RegelsLijst.Items.Item[z].SubItems.Strings[5]);
       end;
     end;

       rootnode := info.Items.Add(nil,'Info');
       RootNode.ImageIndex := 28;
       RootNode.SelectedIndex := 28;

       Node := info.Items.AddChild( RootNode, 'Aantal regels: '+ IntToStr(RegelsLijst.Items.Count) );
       Node.ImageIndex := 47;
       Node.SelectedIndex := 47;

       if ExtraLijst.Count > 0 then
       begin
           rootnode := info.Items.Add(nil,'Regels samengevoegd ('+inttostr(ExtraLijst.Count)+')');
           RootNode.ImageIndex := 15;
           RootNode.SelectedIndex := 15;

           for i := 0 to ExtraLijst.Count - 1 do
           begin
              Node := info.Items.AddChild(RootNode, ExtraLijst.Strings[i]);
              Node.ImageIndex := 47;
              Node.SelectedIndex := 47;

           end;
       end;

       if RegelsTeLang.Count > 0 then
       begin
          rootnode := info.Items.Add(nil,'Regels te lang ('+inttostr(RegelsTeLang.Count)+')');
          RootNode.ImageIndex := 16;
          RootNode.SelectedIndex := 16;

          for i := 0 to RegelsTeLang.Count - 1 do
           begin
              Node := info.Items.AddChild(RootNode, RegelsTeLang.Strings[i]);
              Node.ImageIndex := 47;
              Node.SelectedIndex := 47;
           end;
       end;
     //  info.FullExpand;
  finally
       RegelsTeLang.Clear;
       ExtraLijst.Clear;
    end;
end;

procedure THoofdScherm.VerplaatsSub(Tijd: string);
var
  i: Integer;
begin
  if Tijd = 'Vooruit' then
    begin
      for i := RegelsLijst.ItemIndex to RegelsLijst.Items.count - 1 do
        begin
          RegelsLijst.Items.Item[i].SubItems.Strings[1] := TijdAanpassen(RegelsLijst.Items.Item[i].SubItems.Strings[1],StrToInt64('+'+tijdvar.Text));
          RegelsLijst.Items.Item[i].SubItems.Strings[2] := TijdAanpassen(RegelsLijst.Items.Item[i].SubItems.Strings[2],StrToInt64('+'+tijdvar.Text));
          RegelsLijst.Items.Item[i].SubItems.Strings[3] := UpdateLengte(RegelsLijst.Items.Item[i].SubItems.Strings[1],RegelsLijst.Items.Item[i].SubItems.Strings[2]);
        end;
    end
  else if Tijd = 'Achteruit' then
    begin
      for i := RegelsLijst.ItemIndex to RegelsLijst.Items.count - 1 do
        begin
          RegelsLijst.Items.Item[i].SubItems.Strings[1] := TijdAanpassen(RegelsLijst.Items.Item[i].SubItems.Strings[1],StrToInt64('-'+tijdvar.Text));
          RegelsLijst.Items.Item[i].SubItems.Strings[2] := TijdAanpassen(RegelsLijst.Items.Item[i].SubItems.Strings[2],StrToInt64('-'+tijdvar.Text));
          RegelsLijst.Items.Item[i].SubItems.Strings[3] := UpdateLengte(RegelsLijst.Items.Item[i].SubItems.Strings[1],RegelsLijst.Items.Item[i].SubItems.Strings[2]);
        end;
    end
  else if Tijd = 'BeginAchteruit' then
    begin
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1] := TijdAanpassen(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1],StrToInt64('-'+tijdvar.Text));
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2]);
    end
  else if Tijd = 'BeginVooruit' then
    begin
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1] := TijdAanpassen(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1],StrToInt64('+'+tijdvar.Text));
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2]);
    end
  else if Tijd = 'EindAchteruit' then
    begin
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2] := TijdAanpassen(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2],StrToInt64('-'+tijdvar.Text));
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2]);
    end
  else if Tijd = 'EindVooruit' then
    begin
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2] := TijdAanpassen(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2],StrToInt64('+'+tijdvar.Text));
      RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[3] := UpdateLengte(RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[1],RegelsLijst.Items.Item[RegelsLijst.ItemIndex].SubItems.Strings[2]);
    end;
end;

procedure THoofdScherm.VeranderFontVideo;
var
  size: Integer;
  //height: Integer;
begin
  size := StrToInt(IFontVideo.Text);
//  height := SUB_HEIGHT + (size - SUB_FONT_SIZE) * 10;

//  if height > SUB_MAX_HEIGHT then
//    height := SUB_MAX_HEIGHT;

  {Styxxy, Deze functie wilde niet de subvideoregels vergroten, de font wel
   Heb hem nu op standaard tot 12 staan. wellicht later eens kijken ?}

  with SubVideoRegels do
    begin
      Font.Size := size;
      Height := height;
    end;
end;


{ FUNCTIONS }
function THoofdScherm.ConverteerTijdNaarNano(Tijd: string) : int64;
var
   hh,mm,ss,ms,tt,em: int64;
   layout: string;
begin
     //Strippen die handel :)
     em := 0;
     hh := StrToInt(MidStr(Tijd,1,2)) * 3600;
     mm := StrToInt(MidStr(Tijd,4,2)) * 60;
     ss := StrToInt(MidStr(Tijd,7,2));
     ms := StrToInt(MidStr(Tijd,10,3));
     tt := hh + mm + ss;
       layout := format('%.d%.3d%.4d',[tt,ms,em]);
       Result := StrToInt64(layout);

end;


function THoofdScherm.ConverteerMilliNaarTijd(MilliSeconds: integer): string;
var
  hour,min,sec,msec: Word;
begin
    DecodeTime(MilliSeconds / MiliSecInOneDay, Hour, Min, Sec, MSec);
    Result := Format('%2.2d:%2.2d:%2.2d,%3.3d', [Hour, Min, Sec, Msec]);
end;

function THoofdScherm.TijdAanpassen(Tijd: string; Waarde: int64) : string;
var
  Timer: TDateTime;
begin
  LongTimeFormat := 'hh:nn:ss,zzz';
  Timer := StrToTime(Tijd);
  Timer := incmillisecond(Timer,Waarde);
  Result := TimeToStr(Timer);
end;

function THoofdScherm.UpdateLengte(TijdS: string; TijdE: string) : string;
var
  Calc: TDateTime;
  test: string;
begin
  longtimeformat := 'hh:nn:ss,zzz';
  Calc := StrToTime(TijdE) - StrToTime(TijdS);
  DateTimeToString(test, 'tt', calc);
  Result := test;
end;

procedure THoofdScherm.SamenVoegen1Click(Sender: TObject);
{var
  i: Integer;
  temp: string;
  selected : TListItem;}
begin
  { TO DO }
end;

function THoofdScherm.SecToTime(Sec: int64) : string;
var
  H, M, S: string;
  ZH, ZM, ZS, ZMS: Integer;
begin
  ZMS := Sec;
  ZH := Sec div 3600;
  ZM := Sec div 60 - ZH * 60;
  ZS := Sec - (ZH * 3600 + ZM * 60) ;
  H := IntToStr(ZH) ;
  M := IntToStr(ZM) ;
  S := IntToStr(ZS) ;
  Result := Format ('%.2d:%.2d:%.2d,%.2d', [ZH, ZM, ZS, ZMS]);
end;







end.
